package basics.arrays;

/**
 * Java 数组详细知识点文档
 * 
 * 本文件提供了 Java 数组的全面详细介绍，从基础概念到高级应用
 */
public class JavaArraysDetail {
    
    /**
     * 主方法 - 可以运行此类查看一些数组示例
     */
    public static void main(String[] args) {
        System.out.println("Java 数组详细知识点文档");
        System.out.println("请查看源代码中的注释获取详细信息");
        
        // 展示一些基本示例
        demonstrateArrayBasics();
    }
    
    /**
     * 展示数组基础操作的方法
     */
    private static void demonstrateArrayBasics() {
        // 创建并初始化数组的几种方式
        int[] array1 = new int[5];                // 指定长度
        int[] array2 = {1, 2, 3, 4, 5};           // 使用数组字面量
        int[] array3 = new int[]{5, 4, 3, 2, 1};  // 匿名数组
        
        System.out.println("数组操作示例:");
        
        // 数组遍历
        System.out.println("使用传统for循环遍历:");
        for (int i = 0; i < array2.length; i++) {
            System.out.print(array2[i] + " ");
        }
        System.out.println();
        
        System.out.println("使用增强型for循环遍历:");
        for (int value : array3) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

/**
 * =====================================================
 * 1. 数组基础概念
 * =====================================================
 * 
 * 1.1 数组的本质
 * - 数组是一种引用数据类型，在内存中占用一块连续的空间
 * - 数组变量本身是一个引用，指向堆内存中的数组对象
 * - 数组对象包含一组相同类型的数据元素，可以是基本类型或引用类型
 * - 数组在 Java 中是对象，继承自 Object 类，拥有 length 属性
 * 
 * 1.2 数组的特点
 * - 同质性：数组中所有元素必须是同一数据类型
 * - 有序性：数组中的元素按照索引顺序排列
 * - 固定长度：数组一旦创建，长度不可改变
 * - 随机访问：可以通过索引直接访问任意位置的元素，时间复杂度 O(1)
 * - 内存连续性：数组元素在内存中连续存储，有利于缓存命中率
 * 
 * 1.3 数组的内存模型
 * - 基本类型数组：直接存储值
 * - 引用类型数组：存储对象的引用（地址）
 * - 数组对象存储在堆内存中
 * - 多维数组实际上是"数组的数组"
 * 
 * =====================================================
 * 2. 数组的声明与创建
 * =====================================================
 * 
 * 2.1 数组声明方式
 * // 方式一（推荐）：类型后跟方括号
 * int[] numbers;
 * String[] names;
 * 
 * // 方式二：变量名后跟方括号（不推荐，但合法）
 * int numbers[];
 * String names[];
 * 
 * 2.2 数组创建方式
 * // 方式一：使用 new 关键字创建指定长度的数组
 * int[] numbers = new int[5];  // 创建长度为5的整型数组，默认值为0
 * 
 * // 方式二：使用数组字面量（初始化列表）
 * int[] scores = {95, 85, 75, 65, 55};  // 创建并初始化数组
 * 
 * // 方式三：先声明后创建并初始化
 * int[] points;
 * points = new int[]{10, 20, 30, 40};  // 注意这里不能指定长度
 * 
 * 2.3 数组默认初始化值
 * - 整型数组（byte, short, int, long）：0
 * - 浮点型数组（float, double）：0.0
 * - 字符型数组（char）：'\u0000'（空字符）
 * - 布尔型数组（boolean）：false
 * - 引用类型数组：null
 * 
 * 2.4 匿名数组
 * // 创建匿名数组并传递给方法
 * calculateSum(new int[]{1, 2, 3, 4, 5});
 * 
 * =====================================================
 * 3. 数组的访问与操作
 * =====================================================
 * 
 * 3.1 数组元素访问
 * int[] numbers = {10, 20, 30, 40, 50};
 * int firstElement = numbers[0];  // 访问第一个元素
 * int lastElement = numbers[numbers.length - 1];  // 访问最后一个元素
 * 
 * 3.2 数组长度
 * int length = numbers.length;  // 注意：length 是属性，不是方法
 * 
 * 3.3 数组遍历方式
 * // 方式一：传统 for 循环
 * for (int i = 0; i < numbers.length; i++) {
 *     System.out.println(numbers[i]);
 * }
 * 
 * // 方式二：增强型 for 循环（for-each）
 * for (int number : numbers) {
 *     System.out.println(number);
 * }
 * 
 * // 方式三：Java 8 Stream API
 * Arrays.stream(numbers).forEach(System.out::println);
 * 
 * 3.4 数组边界检查
 * - Java 会进行自动的数组边界检查
 * - 访问越界会抛出 ArrayIndexOutOfBoundsException 异常
 * - 索引必须是非负整数，且小于数组长度
 * 
 * =====================================================
 * 4. 多维数组
 * =====================================================
 * 
 * 4.1 二维数组声明与创建
 * // 声明二维数组
 * int[][] matrix;
 * 
 * // 创建规则二维数组
 * matrix = new int[3][4];  // 3行4列
 * 
 * // 创建不规则二维数组（锯齿数组）
 * int[][] jaggedArray = new int[3][];
 * jaggedArray[0] = new int[4];
 * jaggedArray[1] = new int[2];
 * jaggedArray[2] = new int[5];
 * 
 * // 使用初始化列表
 * int[][] grid = {
 *     {1, 2, 3},
 *     {4, 5, 6},
 *     {7, 8, 9}
 * };
 * 
 * 4.2 二维数组访问
 * int value = matrix[1][2];  // 访问第2行第3列的元素
 * 
 * 4.3 二维数组遍历
 * // 使用嵌套 for 循环
 * for (int i = 0; i < matrix.length; i++) {
 *     for (int j = 0; j < matrix[i].length; j++) {
 *         System.out.print(matrix[i][j] + " ");
 *     }
 *     System.out.println();
 * }
 * 
 * // 使用嵌套增强型 for 循环
 * for (int[] row : matrix) {
 *     for (int value : row) {
 *         System.out.print(value + " ");
 *     }
 *     System.out.println();
 * }
 * 
 * 4.4 多维数组
 * - Java 支持任意维度的数组
 * - 三维数组：int[][][] cube = new int[3][4][5];
 * - 高维数组在实际应用中较少使用
 * 
 * =====================================================
 * 5. Arrays 工具类
 * =====================================================
 * 
 * 5.1 排序
 * int[] numbers = {5, 2, 9, 1, 7};
 * Arrays.sort(numbers);  // 升序排序
 * // 结果：[1, 2, 5, 7, 9]
 * 
 * // 对象数组排序（需实现 Comparable 接口）
 * String[] names = {"张三", "李四", "王五"};
 * Arrays.sort(names);
 * 
 * // 自定义排序（使用 Comparator）
 * Integer[] nums = {5, 2, 9, 1, 7};
 * Arrays.sort(nums, Collections.reverseOrder());  // 降序排序
 * 
 * 5.2 查找
 * int[] numbers = {1, 2, 5, 7, 9};  // 必须是有序数组
 * int index = Arrays.binarySearch(numbers, 5);  // 返回值为2
 * int notFound = Arrays.binarySearch(numbers, 6);  // 返回负值
 * 
 * 5.3 填充
 * int[] numbers = new int[5];
 * Arrays.fill(numbers, 10);  // 填充所有元素为10
 * // 结果：[10, 10, 10, 10, 10]
 * 
 * // 部分填充
 * int[] values = {1, 2, 3, 4, 5};
 * Arrays.fill(values, 1, 4, 8);  // 将索引1到3的元素填充为8
 * // 结果：[1, 8, 8, 8, 5]
 * 
 * 5.4 复制
 * int[] original = {1, 2, 3, 4, 5};
 * int[] copy = Arrays.copyOf(original, 5);  // 完整复制
 * int[] extended = Arrays.copyOf(original, 8);  // 扩展数组长度，新元素为默认值
 * // 结果：[1, 2, 3, 4, 5, 0, 0, 0]
 * 
 * int[] partial = Arrays.copyOfRange(original, 1, 4);  // 复制部分元素
 * // 结果：[2, 3, 4]
 * 
 * 5.5 比较
 * int[] array1 = {1, 2, 3};
 * int[] array2 = {1, 2, 3};
 * boolean isEqual = Arrays.equals(array1, array2);  // true
 * 
 * // 深度比较（多维数组）
 * int[][] matrix1 = {{1, 2}, {3, 4}};
 * int[][] matrix2 = {{1, 2}, {3, 4}};
 * boolean isDeepEqual = Arrays.deepEquals(matrix1, matrix2);  // true
 * 
 * 5.6 转换为字符串
 * int[] numbers = {1, 2, 3, 4, 5};
 * String str = Arrays.toString(numbers);  // "[1, 2, 3, 4, 5]"
 * 
 * // 多维数组
 * int[][] matrix = {{1, 2}, {3, 4}};
 * String deepStr = Arrays.deepToString(matrix);  // "[[1, 2], [3, 4]]"
 * 
 * =====================================================
 * 6. 数组的常见操作与算法
 * =====================================================
 * 
 * 6.1 数组元素求和
 * int[] numbers = {1, 2, 3, 4, 5};
 * int sum = 0;
 * for (int number : numbers) {
 *     sum += number;
 * }
 * // 使用 Stream API
 * int streamSum = Arrays.stream(numbers).sum();
 * 
 * 6.2 查找最大/最小值
 * int[] numbers = {5, 2, 9, 1, 7};
 * int max = numbers[0];
 * int min = numbers[0];
 * for (int i = 1; i < numbers.length; i++) {
 *     if (numbers[i] > max) {
 *         max = numbers[i];
 *     }
 *     if (numbers[i] < min) {
 *         min = numbers[i];
 *     }
 * }
 * // 使用 Stream API
 * int streamMax = Arrays.stream(numbers).max().getAsInt();
 * int streamMin = Arrays.stream(numbers).min().getAsInt();
 * 
 * 6.3 数组反转
 * int[] numbers = {1, 2, 3, 4, 5};
 * for (int i = 0; i < numbers.length / 2; i++) {
 *     int temp = numbers[i];
 *     numbers[i] = numbers[numbers.length - 1 - i];
 *     numbers[numbers.length - 1 - i] = temp;
 * }
 * // 结果：[5, 4, 3, 2, 1]
 * 
 * 6.4 数组合并
 * int[] array1 = {1, 2, 3};
 * int[] array2 = {4, 5, 6};
 * int[] merged = new int[array1.length + array2.length];
 * 
 * System.arraycopy(array1, 0, merged, 0, array1.length);
 * System.arraycopy(array2, 0, merged, array1.length, array2.length);
 * // 结果：[1, 2, 3, 4, 5, 6]
 * 
 * =====================================================
 * 7. 数组的高级特性
 * =====================================================
 * 
 * 7.1 可变参数（Varargs）
 * // 可变参数实际上是数组
 * public static int sum(int... numbers) {
 *     int total = 0;
 *     for (int num : numbers) {
 *         total += num;
 *     }
 *     return total;
 * }
 * 
 * // 调用方式
 * int result1 = sum(1, 2, 3);
 * int result2 = sum(1, 2, 3, 4, 5);
 * int result3 = sum(new int[]{1, 2, 3, 4, 5, 6});
 * 
 * 7.2 数组与集合的转换
 * // 数组转List
 * String[] array = {"Java", "Python", "C++"};
 * List<String> list = Arrays.asList(array);
 * // 注意：asList返回的List是固定大小的，不支持add/remove操作
 * 
 * // 完全可变的List
 * List<String> mutableList = new ArrayList<>(Arrays.asList(array));
 * 
 * // List转数组
 * List<String> languages = new ArrayList<>();
 * languages.add("Java");
 * languages.add("Python");
 * String[] langArray = languages.toArray(new String[0]);
 * 
 * 7.3 数组的克隆
 * int[] original = {1, 2, 3, 4, 5};
 * int[] clone = original.clone();  // 创建数组的浅拷贝
 * 
 * 7.4 System.arraycopy 方法
 * int[] source = {1, 2, 3, 4, 5};
 * int[] dest = new int[5];
 * System.arraycopy(source, 0, dest, 0, source.length);
 * // 参数：源数组，源数组起始位置，目标数组，目标数组起始位置，复制长度
 * 
 * =====================================================
 * 8. 数组的常见问题与注意事项
 * =====================================================
 * 
 * 8.1 数组与内存泄漏
 * - 大型数组使用完毕后应设为 null，帮助垃圾回收
 * - 避免创建过大的数组导致 OutOfMemoryError
 * 
 * 8.2 数组与性能
 * - 数组访问速度快，但大小固定
 * - 需要动态调整大小时，考虑使用 ArrayList
 * - 多维数组访问时注意缓存局部性原理
 * 
 * 8.3 数组与线程安全
 * - 数组本身不是线程安全的
 * - 多线程环境下需要额外同步措施
 * - 考虑使用 CopyOnWriteArrayList 等线程安全集合
 * 
 * 8.4 常见错误
 * - 数组越界访问
 * - 忘记数组索引从0开始
 * - 混淆数组长度和最大索引（length-1）
 * - 在增强型for循环中修改数组元素
 */ 